package login

import (
	"context"
	v1 "donkey-admin/api/task/v1"
	"donkey-admin/internal/consts"
	"donkey-admin/internal/dao"
	"donkey-admin/internal/model/do"
	"donkey-admin/internal/model/entity"
	taskManage "donkey-admin/utility/systask"
	"github.com/gogf/gf/v2/errors/gerror"
	"github.com/gogf/gf/v2/frame/g"
	"github.com/google/uuid"
)

func (s *sTask) CreateSysTask(ctx context.Context, req *v1.CreateSysTaskReq) (res *v1.CreateSysTaskRes, err error) {
	_, err = dao.SysTask.Ctx(ctx).Insert(&do.SysTask{
		Uuid:           uuid.New().String(),
		TaskName:       req.TaskName,
		TaskGroup:      req.TaskGroup,
		CronExpression: req.CronExpression,
		InvokeTarget:   req.InvokeTarget,
		Args:           req.Args,
		HttpMethod:     req.HttpMethod,
		Timeout:        req.Timeout,
		Multi:          req.Multi,
		RetryTimes:     req.RetryTimes,
		RetryInterval:  req.RetryInterval,
		Tag:            req.Tag,
		Remark:         req.Remark,
		Status:         req.Status,
	})
	if err != nil {
		g.Log().Error(ctx, err)
		return nil, gerror.New("创建失败")
	}

	return &v1.CreateSysTaskRes{}, nil
}

func (sTask *sTask) DeleteSysTaskctx(ctx context.Context, req *v1.DeleteTaskReq) (res *v1.DeleteTaskRes, err error) {
	_, err = dao.SysTask.Ctx(ctx).Where("uuid", req.Uuid).Delete()
	if err != nil {
		return nil, err
	}
	return &v1.DeleteTaskRes{}, nil
}

func (sTask *sTask) DeleteSysTaskByIds(ctx context.Context, req *v1.DeleteTaskByIdsReq) (res *v1.DeleteTaskByIdsRes, err error) {
	_, err = dao.SysTask.Ctx(ctx).Where("uuid", req.Uuids).Delete()
	if err != nil {
		g.Log().Error(ctx, err)
		return nil, gerror.New("删除失败")
	}
	return &v1.DeleteTaskByIdsRes{}, nil
}

func (sTask *sTask) UpdateSysTask(ctx context.Context, req *v1.UpdateTaskReq) (res *v1.UpdateTaskRes, err error) {

	_, err = dao.SysTask.Ctx(ctx).Where("uuid", req.Uuid).Update(&do.SysTask{
		TaskName:       req.TaskName,
		TaskGroup:      req.TaskGroup,
		CronExpression: req.CronExpression,
		InvokeTarget:   req.InvokeTarget,
		Args:           req.Args,
		HttpMethod:     req.HttpMethod,
		Timeout:        req.Timeout,
		Multi:          req.Multi,
		RetryTimes:     req.RetryTimes,
		RetryInterval:  req.RetryInterval,
		Tag:            req.Tag,
		Remark:         req.Remark,
		Status:         req.Status,
	})
	if err != nil {
		g.Log().Error(ctx, err)
		return nil, gerror.New("更新失败")
	}

	return &v1.UpdateTaskRes{}, nil
}

func (sTask *sTask) FindSysTask(ctx context.Context, req *v1.FindTaskReq) (res *v1.FindTaskRes, err error) {

	var task entity.SysTask
	err = dao.SysTask.Ctx(ctx).Where("uuid", req.Uuid).Scan(&task)
	if err != nil {
		g.Log().Error(ctx, err)
		return nil, gerror.New("查询失败")
	}

	return &v1.FindTaskRes{}, nil
}

func (sTask *sTask) GetSysTaskList(ctx context.Context, req *v1.GetSysTaskListReq) (res *v1.GetSysTaskListRes, err error) {

	var taskList []entity.SysTask
	err = dao.SysTask.Ctx(ctx).Scan(&taskList)
	if err != nil {
		g.Log().Error(ctx, err)
		return nil, gerror.New("查询失败")
	}
	return &v1.GetSysTaskListRes{TaskList: taskList}, nil
}

// RunOneSysTask RunOne 立即执行任务
func (sTask *sTask) RunOneSysTask(ctx context.Context, req *v1.RunOneSysTaskReq) (res *v1.RunOneSysTaskRes, err error) {
	var task entity.SysTask
	err = dao.SysTask.Ctx(ctx).Where("uuid", req.Uuid).Scan(&task)
	if err != nil {
		g.Log().Error(ctx, err)
		return nil, gerror.New("运行失败")
	}
	task.CronExpression = "手动运行"
	taskManage.SysTaskServiceApp.Run(task)
	return &v1.RunOneSysTaskRes{}, nil
}

// EnableSysTask 激活任务
func (sTask *sTask) EnableSysTask(ctx context.Context, req *v1.EnableSysTaskReq) (res *v1.EnableSysTaskRes, err error) {
	if err = taskManage.SysTaskServiceApp.ChangeStatus(ctx, req.Uuid, consts.Enabled); err != nil {
		return nil, err
	}
	return &v1.EnableSysTaskRes{}, nil
}

// DisableSysTask 暂停任务
func (sTask *sTask) DisableSysTask(ctx context.Context, req *v1.DisableSysTaskReq) (res *v1.DisableSysTaskRes, err error) {
	if err = taskManage.SysTaskServiceApp.ChangeStatus(ctx, req.Uuid, consts.Disabled); err != nil {
		return nil, err
	}
	return &v1.DisableSysTaskRes{}, nil
}

// RemoveSysTask 删除任务
func (sTask *sTask) RemoveSysTask(ctx context.Context, req *v1.RemoveSysTaskReq) (res *v1.RemoveSysTaskRes, err error) {
	err = taskManage.SysTaskServiceApp.DeleteSysTask(ctx, req.Uuid)
	if err != nil {
		g.Log().Error(ctx, err)
		return nil, err
	}
	taskManage.SysTaskServiceApp.Remove(req.Uuid)
	return &v1.RemoveSysTaskRes{}, nil
}
